//TODO 呼叫测试的守护程序部分.


// use std::{
// 	sync::atomic::{AtomicUsize, Ordering},
// 	time::Duration,
// };

// use tokio::sync::mpsc::{error::TryRecvError, Receiver};
// use tracing::{debug, error, info, warn};

// use crate::{db::persistence::InboundDBO, DuplexChannel};

// #[derive(Debug, Clone, Copy)]
// pub enum DialTestCallOver {
// 	///主叫呼叫接通
// 	Success,
// 	///拨号超时
// 	Timeout,
// 	// ///拨号被拒绝
// 	// Refuse,
// 	// ///拨号被取消
// 	// Cancel,
// 	///未知失败
// 	Unknow,
// }

// impl From<DialTestCallOver> for i32 {
// 	fn from(value: DialTestCallOver) -> Self {
// 		match value {
// 			DialTestCallOver::Success => 10,
// 			DialTestCallOver::Timeout => 30,
// 			DialTestCallOver::Unknow => 90,
// 		}
// 	}
// }

// #[derive(Debug)]
// struct DialTestCallers {
// 	callers: Vec<String>,
// 	index: AtomicUsize,
// }

// impl DialTestCallers {
// 	fn new(callers: Vec<String>) -> Self {
// 		Self {
// 			callers,
// 			index: AtomicUsize::new(0),
// 		}
// 	}

// 	fn select_caller(&mut self) -> &str {
// 		let index = self.index.fetch_add(1, Ordering::Relaxed);
// 		if index == self.callers.len() {
// 			self.index.store(0, Ordering::Relaxed);

// 			&self.callers[0]
// 		} else {
// 			&self.callers[index]
// 		}
// 	}

// 	fn is_empty(&self) -> bool {
// 		self.callers.is_empty()
// 	}
// }

// /**
//  * 这是拨测对象，目前来说系统当中仅会有一个此对象在运行当中
//  * 用来获取需要拨测的号码，并呼出，然后判断是否成功
//  */
// #[derive(Debug)]
// pub struct DialTestDaemon {
// 	///拨测对象的唯一id.用来标识此拨测对象
// 	id: &'static str,
// 	///用来接收管理命令，目前只有一个退出
// 	manager_rx: Receiver<ManEvent>,
// 	///用来接收和发送消息，发送拨号和处理结果
// 	channel: DuplexChannel<HandlerToPoint, BusEvent>,
// 	interval: u64,
// }

// impl DialTestDaemon {
// 	///创建拨测对象
// 	pub fn new(
// 		manager_rx: Receiver<ManEvent>,
// 		channel: DuplexChannel<HandlerToPoint, BusEvent>,
// 	) -> Self {
// 		Self {
// 			id: "DIAL_TEST_OBJ",
// 			manager_rx,
// 			channel,
// 			interval: CONFIG.dial_test_interval.into(),
// 		}
// 	}

// 	#[inline]
// 	pub fn id(&self) -> &'static str {
// 		self.id
// 	}

// 	pub async fn start(mut self) {
// 		let mut uuid: String = String::default();
// 		let mut calling = false;
// 		let mut callers = DialTestCallers::new(InboundDBO::load_dial_test_callers().await);
// 		if callers.is_empty() {
// 			warn!("没有读到可用的主叫号码.");
// 			return;
// 		}
// 		let mut called = String::default();
// 		let mut caller = "";

// 		loop {
// 			//判断是否收到结束消息。放这里是为了一次拨测结束进行判断
// 			match self.manager_rx.try_recv() {
// 				Ok(msg) => {
// 					if msg == ManEvent::CLOSE {
// 						info!("拨测收到结束命令，退出此次过程。");
// 						return;
// 					}
// 				}
// 				Err(TryRecvError::Disconnected) => {
// 					info!("拨测检测到对端退出，退出当前过程。");
// 					return;
// 				}
// 				Err(TryRecvError::Empty) => {}
// 			}

// 			//跳过等待时间，再次进行拨测
// 			tokio::time::sleep(Duration::from_secs(self.interval)).await;
// 			match InboundDBO::get_dial_test_info().await {
// 				Ok(Some(cd)) => {
// 					called = cd;
// 					caller = callers.select_caller();
// 					match self.start_dial(caller, &called).await {
// 						Ok(u) => {
// 							//开始进入等待过程
// 							calling = true;
// 							uuid = u;
// 						}
// 						Err(e) => {
// 							error!("dial_test发起呼叫失败.{}", e);
// 							//拨测失败进行记录，并上传结果。以防止中心一直等待
// 							self
// 								.log_dial_test(DialTestCallOver::Unknow, caller, &called)
// 								.await;
// 						}
// 					}
// 				}
// 				Ok(None) => {}
// 				Err(e) => {
// 					error!("获取拨测数据出现异常。{}", e);
// 				}
// 			}

// 			//循环会一直在这里等待挂断为止。因为一定会有一个挂断信号，所以不需要超时判断
// 			while calling {
// 				calling = !self.wait_dial_test_end(&uuid, caller, &called).await;
// 			}
// 		}
// 	}

// 	/// 开始进行拨号
// 	#[inline]
// 	async fn start_dial(&mut self, caller: &str, called: &str) -> crate::Result<String> {
// 		let uuid = Uuid::new_v4().to_string();

// 		//发送绑定信息给连接,以便于后续接收到来自呼叫通道的信息
// 		self
// 			.channel
// 			.tx
// 			.send(HandlerToPoint::Bind(vec![
// 				self.id.to_string(),
// 				uuid.clone(),
// 			]))
// 			.await?;

// 		//发送呼叫信息给连接.发起呼叫
// 		originate(
// 			&self.channel.tx,
// 			&uuid,
// 			caller,
// 			caller,
// 			&DialTestDaemon::completion_turn_num(CONFIG.sip_url, called),
// 			10,
// 		)
// 		.await?;

// 		Ok(uuid)
// 	}

// 	#[inline]
// 	fn completion_turn_num(url: &str, num: &str) -> String {
// 		format!("sofia/internal/sip:{}@{}", num, url)
// 	}

// 	#[inline]
// 	async fn log_dial_test(&self, status: DialTestCallOver, caller: &str, called: &str) {
// 		if let Err(e) = InboundDBO::dial_test_call_over(caller, called, status.into()).await {
// 			error!("上传拨测结果操作失败。{}", e);
// 		}
// 	}

// 	///等待此次拨号的结束操作。在此方法内会有阻塞，
// 	/// 如果未结束，返回false,结束了返回true
// 	#[inline]
// 	async fn wait_dial_test_end(&mut self, uuid: &str, caller: &str, called: &str) -> bool {
// 		match self.channel.rx.recv().await {
// 			//因为应答以后这里会跳出，不再处理消息，这里收到的挂断应该只有主叫挂断操作
// 			Some(BusEvent::ChannelHangup(hangup)) if hangup.uuid == uuid => {
// 				info!("拨测挂断结束，挂断。{:?}", &hangup);

// 				self
// 					.log_dial_test(DialTestCallOver::Timeout, caller, called)
// 					.await;

// 				true
// 			}
// 			//应答消息。这里只有单边，所以只能是被叫接通
// 			Some(BusEvent::ChannelAnswer(msg)) if msg.uuid == uuid => {
// 				debug!("拨测收到呼叫被叫接通。{:?}", msg);

// 				self
// 					.log_dial_test(DialTestCallOver::Success, caller, called)
// 					.await;

// 				true
// 			}
// 			Some(msg) => {
// 				debug!("收到消息，记录一下。{:?}", msg);

// 				false
// 			}
// 			None => true,
// 		}
// 	}
// }
